home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / distutils / dir_util.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  7KB  |  196 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''distutils.dir_util
  5.  
  6. Utility functions for manipulating directories and directory trees.'''
  7. __revision__ = '$Id: dir_util.py,v 1.15.2.1 2005/08/24 14:55:42 loewis Exp $'
  8. import os
  9. import sys
  10. from types import *
  11. from distutils.errors import DistutilsFileError, DistutilsInternalError
  12. from distutils import log
  13. _path_created = { }
  14.  
  15. def mkpath(name, mode = 511, verbose = 0, dry_run = 0):
  16.     """Create a directory and any missing ancestor directories.  If the
  17.        directory already exists (or if 'name' is the empty string, which
  18.        means the current directory, which of course exists), then do
  19.        nothing.  Raise DistutilsFileError if unable to create some
  20.        directory along the way (eg. some sub-path exists, but is a file
  21.        rather than a directory).  If 'verbose' is true, print a one-line
  22.        summary of each mkdir to stdout.  Return the list of directories
  23.        actually created."""
  24.     if not isinstance(name, StringTypes):
  25.         raise DistutilsInternalError, "mkpath: 'name' must be a string (got %r)" % (name,)
  26.     
  27.     name = os.path.normpath(name)
  28.     created_dirs = []
  29.     if os.path.isdir(name) or name == '':
  30.         return created_dirs
  31.     
  32.     if _path_created.get(os.path.abspath(name)):
  33.         return created_dirs
  34.     
  35.     (head, tail) = os.path.split(name)
  36.     tails = [
  37.         tail]
  38.     while head and tail and not os.path.isdir(head):
  39.         (head, tail) = os.path.split(head)
  40.         tails.insert(0, tail)
  41.     for d in tails:
  42.         head = os.path.join(head, d)
  43.         abs_head = os.path.abspath(head)
  44.         if _path_created.get(abs_head):
  45.             continue
  46.         
  47.         log.info('creating %s', head)
  48.         if not dry_run:
  49.             
  50.             try:
  51.                 os.mkdir(head)
  52.                 created_dirs.append(head)
  53.             except OSError:
  54.                 exc = None
  55.                 raise DistutilsFileError, "could not create '%s': %s" % (head, exc[-1])
  56.             except:
  57.                 None<EXCEPTION MATCH>OSError
  58.             
  59.  
  60.         None<EXCEPTION MATCH>OSError
  61.         _path_created[abs_head] = 1
  62.     
  63.     return created_dirs
  64.  
  65.  
  66. def create_tree(base_dir, files, mode = 511, verbose = 0, dry_run = 0):
  67.     """Create all the empty directories under 'base_dir' needed to
  68.        put 'files' there.  'base_dir' is just the a name of a directory
  69.        which doesn't necessarily exist yet; 'files' is a list of filenames
  70.        to be interpreted relative to 'base_dir'.  'base_dir' + the
  71.        directory portion of every file in 'files' will be created if it
  72.        doesn't already exist.  'mode', 'verbose' and 'dry_run' flags are as
  73.        for 'mkpath()'."""
  74.     need_dir = { }
  75.     for file in files:
  76.         need_dir[os.path.join(base_dir, os.path.dirname(file))] = 1
  77.     
  78.     need_dirs = need_dir.keys()
  79.     need_dirs.sort()
  80.     for dir in need_dirs:
  81.         mkpath(dir, mode, dry_run = dry_run)
  82.     
  83.  
  84.  
  85. def copy_tree(src, dst, preserve_mode = 1, preserve_times = 1, preserve_symlinks = 0, update = 0, verbose = 0, dry_run = 0):
  86.     """Copy an entire directory tree 'src' to a new location 'dst'.  Both
  87.        'src' and 'dst' must be directory names.  If 'src' is not a
  88.        directory, raise DistutilsFileError.  If 'dst' does not exist, it is
  89.        created with 'mkpath()'.  The end result of the copy is that every
  90.        file in 'src' is copied to 'dst', and directories under 'src' are
  91.        recursively copied to 'dst'.  Return the list of files that were
  92.        copied or might have been copied, using their output name.  The
  93.        return value is unaffected by 'update' or 'dry_run': it is simply
  94.        the list of all files under 'src', with the names changed to be
  95.        under 'dst'.
  96.  
  97.        'preserve_mode' and 'preserve_times' are the same as for
  98.        'copy_file'; note that they only apply to regular files, not to
  99.        directories.  If 'preserve_symlinks' is true, symlinks will be
  100.        copied as symlinks (on platforms that support them!); otherwise
  101.        (the default), the destination of the symlink will be copied.
  102.        'update' and 'verbose' are the same as for 'copy_file'."""
  103.     copy_file = copy_file
  104.     import distutils.file_util
  105.     if not dry_run and not os.path.isdir(src):
  106.         raise DistutilsFileError, "cannot copy tree '%s': not a directory" % src
  107.     
  108.     
  109.     try:
  110.         names = os.listdir(src)
  111.     except os.error:
  112.         (errno, errstr) = None
  113.         if dry_run:
  114.             names = []
  115.         else:
  116.             raise DistutilsFileError, "error listing files in '%s': %s" % (src, errstr)
  117.     except:
  118.         dry_run
  119.  
  120.     if not dry_run:
  121.         mkpath(dst)
  122.     
  123.     outputs = []
  124.     for n in names:
  125.         src_name = os.path.join(src, n)
  126.         dst_name = os.path.join(dst, n)
  127.         if preserve_symlinks and os.path.islink(src_name):
  128.             link_dest = os.readlink(src_name)
  129.             log.info('linking %s -> %s', dst_name, link_dest)
  130.             if not dry_run:
  131.                 os.symlink(link_dest, dst_name)
  132.             
  133.             outputs.append(dst_name)
  134.             continue
  135.         if os.path.isdir(src_name):
  136.             outputs.extend(copy_tree(src_name, dst_name, preserve_mode, preserve_times, preserve_symlinks, update, dry_run = dry_run))
  137.             continue
  138.         copy_file(src_name, dst_name, preserve_mode, preserve_times, update, dry_run = dry_run)
  139.         outputs.append(dst_name)
  140.     
  141.     return outputs
  142.  
  143.  
  144. def _build_cmdtuple(path, cmdtuples):
  145.     for f in os.listdir(path):
  146.         real_f = os.path.join(path, f)
  147.         if os.path.isdir(real_f) and not os.path.islink(real_f):
  148.             _build_cmdtuple(real_f, cmdtuples)
  149.             continue
  150.         cmdtuples.append((os.remove, real_f))
  151.     
  152.     cmdtuples.append((os.rmdir, path))
  153.  
  154.  
  155. def remove_tree(directory, verbose = 0, dry_run = 0):
  156.     """Recursively remove an entire directory tree.  Any errors are ignored
  157.     (apart from being reported to stdout if 'verbose' is true).
  158.     """
  159.     grok_environment_error = grok_environment_error
  160.     import distutils.util
  161.     log.info("removing '%s' (and everything under it)", directory)
  162.     if dry_run:
  163.         return None
  164.     
  165.     cmdtuples = []
  166.     _build_cmdtuple(directory, cmdtuples)
  167.     for cmd in cmdtuples:
  168.         
  169.         try:
  170.             apply(cmd[0], (cmd[1],))
  171.             abspath = os.path.abspath(cmd[1])
  172.             if _path_created.has_key(abspath):
  173.                 del _path_created[abspath]
  174.         continue
  175.         except (IOError, OSError):
  176.             exc = None
  177.             log.warn(grok_environment_error(exc, 'error removing %s: ' % directory))
  178.             continue
  179.         
  180.  
  181.     
  182.  
  183.  
  184. def ensure_relative(path):
  185.     """Take the full path 'path', and make it a relative path so
  186.     it can be the second argument to os.path.join().
  187.     """
  188.     (drive, path) = os.path.splitdrive(path)
  189.     if sys.platform == 'mac':
  190.         return os.sep + path
  191.     elif path[0:1] == os.sep:
  192.         path = drive + path[1:]
  193.     
  194.     return path
  195.  
  196.